Taek_Blog - advanced

Pandas Basic

1 Advanced Python CH5 - Pandas Basic

import numpy as np
import pandas as pd

from pandas import Series, DataFrame

import numpy as np
np.random.seed(12345)
import matplotlib.pyplot as plt
plt.rc("figure", figsize=(10, 6))
PREVIOUS_MAX_ROWS = pd.options.display.max_rows
pd.options.display.max_rows = 20
pd.options.display.max_columns = 20
pd.options.display.max_colwidth = 80
np.set_printoptions(precision=4, suppress=True)

2 Introduction to pandas Data Structures

판다스 시리즈 객체

obj = pd.Series([4, 7, -5, 3])
obj

0    4
1    7
2   -5
3    3
dtype: int64

obj.array

<PandasArray>
[4, 7, -5, 3]
Length: 4, dtype: int64

obj.index

RangeIndex(start=0, stop=4, step=1)

obj2 = pd.Series([4, 7, -5, 3], index=["d", "b", "a", "c"])
obj2

d    4
b    7
a   -5
c    3
dtype: int64

obj2.index

Index(['d', 'b', 'a', 'c'], dtype='object')

obj2["a"]
obj2["d"] = 6
obj2[["c", "a", "d"]] # 입력 순서대로 정렬

c    3
a   -5
d    6
dtype: int64

obj2[obj2 > 0]

d    6
b    7
c    3
dtype: int64

obj2 * 2

d    12
b    14
a   -10
c     6
dtype: int64

np.exp(obj2)

d     403.428793
b    1096.633158
a       0.006738
c      20.085537
dtype: float64

"b" in obj2, "e" in obj2

(True, False)

딕셔너리로 시리즈 객체 만들기

sdata = {"Ohio": 35000, "Texas": 71000, "Oregon": 16000, "Utah": 5000}
obj3 = pd.Series(sdata)
obj3

Ohio      35000
Texas     71000
Oregon    16000
Utah       5000
dtype: int64

obj3.to_dict() # to_dict : 딕셔너리로 불러오기

{'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

states = ["California", "Ohio", "Oregon", "Texas"]
obj4 = pd.Series(sdata, index=states)
obj4 # 새로운 인덱스 값의 value 값은 NaN

California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

pd.isna(obj4)

California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

pd.notna(obj4)

California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

obj4.isna()

California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

obj3
obj4
obj3 + obj4 # 중복없는 인덱스 값의 value 값은 NaN

California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

obj4.name = "population"
obj4.index.name = "state"
obj4

state
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
Name: population, dtype: float64

obj
obj.index = ["Bob", "Steve", "Jeff", "Ryan"]
obj # 인덱스 이름 부여

Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

3 DataFrame

data = {"state": ["Ohio", "Ohio", "Ohio", "Nevada", "Nevada", "Nevada"],
        "year": [2000, 2001, 2002, 2001, 2002, 2003],
        "pop": [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
frame = pd.DataFrame(data)

frame

	state	year	pop
0	Ohio	2000	1.5
1	Ohio	2001	1.7
2	Ohio	2002	3.6
3	Nevada	2001	2.4
4	Nevada	2002	2.9
5	Nevada	2003	3.2

frame.head()

	state	year	pop
0	Ohio	2000	1.5
1	Ohio	2001	1.7
2	Ohio	2002	3.6
3	Nevada	2001	2.4
4	Nevada	2002	2.9

frame.tail()

	state	year	pop
1	Ohio	2001	1.7
2	Ohio	2002	3.6
3	Nevada	2001	2.4
4	Nevada	2002	2.9
5	Nevada	2003	3.2

pd.DataFrame(data, columns=["year", "state", "pop"]) # 컬럼 순서 지정

	year	state	pop
0	2000	Ohio	1.5
1	2001	Ohio	1.7
2	2002	Ohio	3.6
3	2001	Nevada	2.4
4	2002	Nevada	2.9
5	2003	Nevada	3.2

frame2 = pd.DataFrame(data, columns=["year", "state", "pop", "debt"])
frame2 # 새로운 컬럼 값 지정 안하면 NaN

	year	state	pop	debt
0	2000	Ohio	1.5	NaN
1	2001	Ohio	1.7	NaN
2	2002	Ohio	3.6	NaN
3	2001	Nevada	2.4	NaN
4	2002	Nevada	2.9	NaN
5	2003	Nevada	3.2	NaN

frame2.columns

Index(['year', 'state', 'pop', 'debt'], dtype='object')

frame2["state"]

0      Ohio
1      Ohio
2      Ohio
3    Nevada
4    Nevada
5    Nevada
Name: state, dtype: object

frame2.year

0    2000
1    2001
2    2002
3    2001
4    2002
5    2003
Name: year, dtype: int64

frame2.loc[1] # 행 추출

year     2001
state    Ohio
pop       1.7
debt      NaN
Name: 1, dtype: object

frame2.iloc[2] # 인덱스가 2인것 추출

year     2002
state    Ohio
pop       3.6
debt      NaN
Name: 2, dtype: object

frame2["debt"] = 16.5
frame2

	year	state	pop	debt
0	2000	Ohio	1.5	16.5
1	2001	Ohio	1.7	16.5
2	2002	Ohio	3.6	16.5
3	2001	Nevada	2.4	16.5
4	2002	Nevada	2.9	16.5
5	2003	Nevada	3.2	16.5

frame2["debt"] = np.arange(6.)
frame2

	year	state	pop	debt
0	2000	Ohio	1.5	0.0
1	2001	Ohio	1.7	1.0
2	2002	Ohio	3.6	2.0
3	2001	Nevada	2.4	3.0
4	2002	Nevada	2.9	4.0
5	2003	Nevada	3.2	5.0

val = pd.Series([-1.2, -1.5, -1.7], index=["two", "four", "five"])
frame2["debt"] = val
frame2

	year	state	pop	debt
0	2000	Ohio	1.5	NaN
1	2001	Ohio	1.7	NaN
2	2002	Ohio	3.6	NaN
3	2001	Nevada	2.4	NaN
4	2002	Nevada	2.9	NaN
5	2003	Nevada	3.2	NaN

frame2["eastern"] = frame2["state"] == "Ohio"
frame2

	year	state	pop	debt	eastern
0	2000	Ohio	1.5	NaN	True
1	2001	Ohio	1.7	NaN	True
2	2002	Ohio	3.6	NaN	True
3	2001	Nevada	2.4	NaN	False
4	2002	Nevada	2.9	NaN	False
5	2003	Nevada	3.2	NaN	False

del frame2["eastern"]
frame2

	year	state	pop	debt
0	2000	Ohio	1.5	NaN
1	2001	Ohio	1.7	NaN
2	2002	Ohio	3.6	NaN
3	2001	Nevada	2.4	NaN
4	2002	Nevada	2.9	NaN
5	2003	Nevada	3.2	NaN

frame2.columns

Index(['year', 'state', 'pop', 'debt'], dtype='object')

populations = {"Ohio": {2000: 1.5, 2001: 1.7, 2002: 3.6},
               "Nevada": {2001: 2.4, 2002: 2.9}} # 인덱스에 직접 값 지정

frame3 = pd.DataFrame(populations)
frame3

	Ohio	Nevada
2000	1.5	NaN
2001	1.7	2.4
2002	3.6	2.9

frame3.T # 행,열 위치 바꾸기

	2000	2001	2002
Ohio	1.5	1.7	3.6
Nevada	NaN	2.4	2.9

pd.DataFrame(populations, index=[2001, 2002, 2003]) # 새로운 인덱스는 NaN

	Ohio	Nevada
2001	1.7	2.4
2002	3.6	2.9
2003	NaN	NaN

pdata = {"Ohio": frame3["Ohio"][:-1],
         "Nevada": frame3["Nevada"][:2]}
pd.DataFrame(pdata) # 기존 DF에 조건걸기

	Ohio	Nevada
2000	1.5	NaN
2001	1.7	2.4

frame3.index.name = "year"
frame3.columns.name = "state"
frame3

state	Ohio	Nevada
year
2000	1.5	NaN
2001	1.7	2.4
2002	3.6	2.9

frame3.to_numpy()

array([[1.5, nan],
       [1.7, 2.4],
       [3.6, 2.9]])

frame2.to_numpy()

array([[2000, 'Ohio', 1.5, nan],
       [2001, 'Ohio', 1.7, nan],
       [2002, 'Ohio', 3.6, nan],
       [2001, 'Nevada', 2.4, nan],
       [2002, 'Nevada', 2.9, nan],
       [2003, 'Nevada', 3.2, nan]], dtype=object)

4 Index Objects

obj = pd.Series(np.arange(3), index=["a", "b", "c"])
index = obj.index
index
index[1:]

Index(['b', 'c'], dtype='object')

labels = pd.Index(np.arange(3))
labels
obj2 = pd.Series([1.5, -2.5, 0], index=labels)
obj2
obj2.index is labels # 동일한 인덱스 인가

True

frame3
frame3.columns
"Ohio" in frame3.columns
2003 in frame3.index

False

pd.Index(["foo", "foo", "bar", "bar"])

Index(['foo', 'foo', 'bar', 'bar'], dtype='object')

5 Essential Functionality

5.1 ReIndexing

obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=["d", "b", "a", "c"])
obj

d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

obj2 = obj.reindex(["a", "b", "c", "d", "e"])
obj2

a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64

obj3 = pd.Series(["blue", "purple", "yellow"], index=[0, 2, 4])
obj3
obj3.reindex(np.arange(6), method="ffill") # reindex ffill : 앞에 있는 값으로 채우가

0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

frame = pd.DataFrame(np.arange(9).reshape((3, 3)), # 3x3 형태, 0,1,2,... 채우기
                     index=["a", "c", "d"],
                     columns=["Ohio", "Texas", "California"])
frame
frame2 = frame.reindex(index=["a", "b", "c", "d"])
frame2

	Ohio	Texas	California
a	0.0	1.0	2.0
b	NaN	NaN	NaN
c	3.0	4.0	5.0
d	6.0	7.0	8.0

states = ["Texas", "Utah", "California"]
frame.reindex(columns=states) # 새로운 컬럼은 NaN

	Texas	Utah	California
a	1	NaN	2
c	4	NaN	5
d	7	NaN	8

frame.reindex(states, axis="columns") # 위랑 다른형식, 같은값

	Texas	Utah	California
a	1	NaN	2
c	4	NaN	5
d	7	NaN	8

frame.loc[["a", "d", "c"], ["California", "Texas"]] # 해당 행, 해당 컬럼 추출

	California	Texas
a	2	1
d	8	7
c	5	4

5.2 Dropping Entries from an Axis

obj = pd.Series(np.arange(5.), index=["a", "b", "c", "d", "e"])
obj
new_obj = obj.drop("c")
new_obj
obj.drop(["d", "c"])

a    0.0
b    1.0
e    4.0
dtype: float64

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=["Ohio", "Colorado", "Utah", "New York"],
                    columns=["one", "two", "three", "four"])
data

	one	two	three	four
Ohio	0	1	2	3
Colorado	4	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

data.drop(index=["Colorado", "Ohio"]) # 인덱스 드랍

	one	two	three	four
Utah	8	9	10	11
New York	12	13	14	15

data.drop(columns=["two"]) # 컬럼 드랍

	one	three	four
Ohio	0	2	3
Colorado	4	6	7
Utah	8	10	11
New York	12	14	15

data.drop("two", axis=1)

	one	three	four
Ohio	0	2	3
Colorado	4	6	7
Utah	8	10	11
New York	12	14	15

data.drop(["two", "four"], axis="columns")

	one	three
Ohio	0	2
Colorado	4	6
Utah	8	10
New York	12	14

obj.drop('c', inplace=True) # 원본 시리즈 변경(대체)
obj

a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64

5.3 Indexing, Selection, and Filtering

obj = pd.Series(np.arange(4.), index=["a", "b", "c", "d"])
obj

a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64

obj["b"]

1.0

obj[1] # 인덱스 1 의 value 값

1.0

obj[2:4]

c    2.0
d    3.0
dtype: float64

obj[["b", "a", "d"]]

b    1.0
a    0.0
d    3.0
dtype: float64

obj[[1, 3]]

b    1.0
d    3.0
dtype: float64

obj[obj < 2] # 값이 2보다 작은것

a    0.0
b    1.0
dtype: float64

obj.loc[["b", "a", "d"]]

b    1.0
a    0.0
d    3.0
dtype: float64

obj1 = pd.Series([1, 2, 3], index=[2, 0, 1])
obj2 = pd.Series([1, 2, 3], index=["a", "b", "c"])
obj1
obj2
obj1[[0, 1, 2]]
obj2[[0, 1, 2]] # 지정 순서대로

a    1
b    2
c    3
dtype: int64

obj1.iloc[[0, 1, 2]] # iloc : 위치기반

2    1
0    2
1    3
dtype: int64

obj2.iloc[[0, 1, 2]]

a    1
b    2
c    3
dtype: int64

obj2.loc["b":"c"]

b    2
c    3
dtype: int64

obj2.loc["b":"c"] = 5
obj2

a    1
b    5
c    5
dtype: int64

data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                    index=["Ohio", "Colorado", "Utah", "New York"],
                    columns=["one", "two", "three", "four"])
data
data["two"]
data[["three", "one"]]

	three	one
Ohio	2	0
Colorado	6	4
Utah	10	8
New York	14	12

data[:2] # 행

	one	two	three	four
Ohio	0	1	2	3
Colorado	4	5	6	7

data[data["three"] > 5]

	one	two	three	four
Colorado	4	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

data < 5

	one	two	three	four
Ohio	True	True	True	True
Colorado	True	False	False	False
Utah	False	False	False	False
New York	False	False	False	False

data[data < 5] = 0
data

	one	two	three	four
Ohio	0	0	0	0
Colorado	0	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

5.4 Selection with loc & iloc

data

	one	two	three	four
Ohio	0	0	0	0
Colorado	0	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

data.loc["Colorado"]

one      0
two      5
three    6
four     7
Name: Colorado, dtype: int32

data.loc[["Colorado", "New York"]]

	one	two	three	four
Colorado	0	5	6	7
New York	12	13	14	15

data.loc["Colorado", ["two", "three"]] # 해당 행인덱스의 해당 열값

two      5
three    6
Name: Colorado, dtype: int32

data.iloc[2]

one       8
two       9
three    10
four     11
Name: Utah, dtype: int32

data.iloc[[2, 1]]

	one	two	three	four
Utah	8	9	10	11
Colorado	0	5	6	7

data.iloc[2, [3, 0, 1]] # 열 값 순서 지정도 가능

four    11
one      8
two      9
Name: Utah, dtype: int32

data.iloc[[1, 2], [3, 0, 1]]

	four	one	two
Colorado	7	0	5
Utah	11	8	9

data.loc[:"Utah", "two"]

Ohio        0
Colorado    5
Utah        9
Name: two, dtype: int32

data.iloc[:, :3][data.three > 5] # 모든행, 3전까지 열

	one	two	three
Colorado	0	5	6
Utah	8	9	10
New York	12	13	14

data.loc[data.three >= 2] # 해당값이 2이상인것 추출

	one	two	three	four
Colorado	0	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

5.5 Integer Indexes

ser = pd.Series(np.arange(3.))
ser

0    0.0
1    1.0
2    2.0
dtype: float64

ser.iloc[-1] # 마지막 선택

2.0

ser2 = pd.Series(np.arange(3.), index=["a", "b", "c"])
ser2

a    0.0
b    1.0
c    2.0
dtype: float64

ser2[-1]

2.0

ser.iloc[-1]

2.0

ser[:2]

0    0.0
1    1.0
dtype: float64

data

	one	two	three	four
Ohio	0	0	0	0
Colorado	0	5	6	7
Utah	8	9	10	11
New York	12	13	14	15

loc, iloc로 값 바꾸기

data.loc[:, "one"] = 1
data

	one	two	three	four
Ohio	1	0	0	0
Colorado	1	5	6	7
Utah	1	9	10	11
New York	1	13	14	15

data.iloc[2] = 5
data

	one	two	three	four
Ohio	1	0	0	0
Colorado	1	5	6	7
Utah	5	5	5	5
New York	1	13	14	15

data.loc[data["four"] > 5] = 3
data

	one	two	three	four
Ohio	1	0	0	0
Colorado	3	3	3	3
Utah	5	5	5	5
New York	3	3	3	3

data.loc[data.three == 5]["three"] = 6
data # 잘못된 경우

C:\Users\seong taek\AppData\Local\Temp\ipykernel_15512\2485902161.py:1: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  data.loc[data.three == 5]["three"] = 6

	one	two	three	four
Ohio	1	0	0	0
Colorado	3	3	3	3
Utah	5	5	5	5
New York	3	3	3	3

data.loc[data.three == 5, "three"] = 6
data

	one	two	three	four
Ohio	1	0	0	0
Colorado	3	3	3	3
Utah	5	5	6	5
New York	3	3	3	3

5.6 Arithmetic & Data Alignment

s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=["a", "c", "d", "e"])
s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],
               index=["a", "c", "e", "f", "g"])
s1

a    7.3
c   -2.5
d    3.4
e    1.5
dtype: float64

s2

a   -2.1
c    3.6
e   -1.5
f    4.0
g    3.1
dtype: float64

s1 + s2 # 시리즈끼리 더하면 하나라도 없는값 NaN

a    5.2
c    1.1
d    NaN
e    0.0
f    NaN
g    NaN
dtype: float64

df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list("bcd"),
                   index=["Ohio", "Texas", "Colorado"])
df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list("bde"),
                   index=["Utah", "Ohio", "Texas", "Oregon"])
df1

	b	c	d
Ohio	0.0	1.0	2.0
Texas	3.0	4.0	5.0
Colorado	6.0	7.0	8.0

df2

	b	d	e
Utah	0.0	1.0	2.0
Ohio	3.0	4.0	5.0
Texas	6.0	7.0	8.0
Oregon	9.0	10.0	11.0

df1 + df2 # 없는 행이나 열: NaN

	b	c	d	e
Colorado	NaN	NaN	NaN	NaN
Ohio	3.0	NaN	6.0	NaN
Oregon	NaN	NaN	NaN	NaN
Texas	9.0	NaN	12.0	NaN
Utah	NaN	NaN	NaN	NaN

df1 = pd.DataFrame({"A": [1, 2]})
df2 = pd.DataFrame({"B": [3, 4]})
df1
df2

	B
0	3
1	4

df1 + df2

	A	B
0	NaN	NaN
1	NaN	NaN

df1 = pd.DataFrame(np.arange(12.).reshape((3, 4)),
                   columns=list("abcd"))
df2 = pd.DataFrame(np.arange(20.).reshape((4, 5)),
                   columns=list("abcde"))
df2

	a	b	c	d	e
0	0.0	1.0	2.0	3.0	4.0
1	5.0	6.0	7.0	8.0	9.0
2	10.0	11.0	12.0	13.0	14.0
3	15.0	16.0	17.0	18.0	19.0

df2.loc[1, "b"] = np.nan
df2

	a	b	c	d	e
0	0.0	1.0	2.0	3.0	4.0
1	5.0	NaN	7.0	8.0	9.0
2	10.0	11.0	12.0	13.0	14.0
3	15.0	16.0	17.0	18.0	19.0

df1

	a	b	c	d
0	0.0	1.0	2.0	3.0
1	4.0	5.0	6.0	7.0
2	8.0	9.0	10.0	11.0

df1 + df2

	a	b	c	d	e
0	0.0	2.0	4.0	6.0	NaN
1	9.0	NaN	13.0	15.0	NaN
2	18.0	20.0	22.0	24.0	NaN
3	NaN	NaN	NaN	NaN	NaN

df1.add(df2, fill_value=0) # NaN 값 되는거

	a	b	c	d	e
0	0.0	2.0	4.0	6.0	4.0
1	9.0	5.0	13.0	15.0	9.0
2	18.0	20.0	22.0	24.0	14.0
3	15.0	16.0	17.0	18.0	19.0

df1

	a	b	c	d
0	0.0	1.0	2.0	3.0
1	4.0	5.0	6.0	7.0
2	8.0	9.0	10.0	11.0

1 / df1

	a	b	c	d
0	inf	1.000000	0.500000	0.333333
1	0.250	0.200000	0.166667	0.142857
2	0.125	0.111111	0.100000	0.090909

df1.rdiv(1) # 역수

	a	b	c	d
0	inf	1.000000	0.500000	0.333333
1	0.250	0.200000	0.166667	0.142857
2	0.125	0.111111	0.100000	0.090909

df1.reindex(columns=df2.columns, fill_value=0) # 컬럼 추가

	a	b	c	d
0	0.0	1.0	2.0	3.0
1	4.0	5.0	6.0	7.0
2	8.0	9.0	10.0	11.0

df1.reindex(columns=['e'], fill_value=0)

	e
0	0
1	0
2	0

arr = np.arange(12.).reshape((3, 4))
arr

array([[ 0.,  1.,  2.,  3.],
       [ 4.,  5.,  6.,  7.],
       [ 8.,  9., 10., 11.]])

arr[0]

array([0., 1., 2., 3.])

arr - arr[0] # 각각의 행값이 계산됨

array([[0., 0., 0., 0.],
       [4., 4., 4., 4.],
       [8., 8., 8., 8.]])

frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                     columns=list("bde"),
                     index=["Utah", "Ohio", "Texas", "Oregon"])
series = frame.iloc[0]
series

b    0.0
d    1.0
e    2.0
Name: Utah, dtype: float64

frame

	b	d	e
Utah	0.0	1.0	2.0
Ohio	3.0	4.0	5.0
Texas	6.0	7.0	8.0
Oregon	9.0	10.0	11.0

frame - series # 시리즈 값만큼 각각 계산

	b	d	e
Utah	0.0	0.0	0.0
Ohio	3.0	3.0	3.0
Texas	6.0	6.0	6.0
Oregon	9.0	9.0	9.0

series2 = pd.Series(np.arange(3), index=["b", "e", "f"])
series2

b    0
e    1
f    2
dtype: int32

frame + series2

	b	d	e	f
Utah	0.0	NaN	3.0	NaN
Ohio	3.0	NaN	6.0	NaN
Texas	6.0	NaN	9.0	NaN
Oregon	9.0	NaN	12.0	NaN

series3 = frame["d"]
series3

Utah       1.0
Ohio       4.0
Texas      7.0
Oregon    10.0
Name: d, dtype: float64

frame.sub(series3, axis="index") # index기준으로 빼기

	b	e
Utah	-1.0	1.0
Ohio	-1.0	1.0
Texas	-1.0	1.0
Oregon	-1.0	1.0

frame = pd.DataFrame(np.random.standard_normal((4, 3)),
                     columns=list("bde"),
                     index=["Utah", "Ohio", "Texas", "Oregon"])
frame
np.abs(frame)

	b	d	e
Utah	0.204708	0.478943	0.519439
Ohio	0.555730	1.965781	1.393406
Texas	0.092908	0.281746	0.769023
Oregon	1.246435	1.007189	1.296221

frame

	b	d	e
Utah	-0.204708	0.478943	-0.519439
Ohio	-0.555730	1.965781	1.393406
Texas	0.092908	0.281746	0.769023
Oregon	1.246435	1.007189	-1.296221

def f1(x):
    return x.max() - x.min() # 열기준

frame.apply(f1)

b    1.802165
d    1.684034
e    2.689627
dtype: float64

frame.apply(f1, axis="columns") # 각 행에 대해

Utah      0.998382
Ohio      2.521511
Texas     0.676115
Oregon    2.542656
dtype: float64

def f2(x):
    return pd.Series([x.min(), x.max()], index=["min", "max"]) # 시리즈 객체로 최대/최소 값, 인덱스 지정
frame.apply(f2)

	b	d	e
min	-0.555730	0.281746	-1.296221
max	1.246435	1.965781	1.393406

def my_format(x):
    return f"{x:.2f}" # 소수점 둘째자리 까지 반올림

frame.applymap(my_format)

	b	d	e
Utah	-0.20	0.48	-0.52
Ohio	-0.56	1.97	1.39
Texas	0.09	0.28	0.77
Oregon	1.25	1.01	-1.30

frame["e"].map(my_format) # 소수점 둘째자리 까지 반올림 (map:호출)

Utah      -0.52
Ohio       1.39
Texas      0.77
Oregon    -1.30
Name: e, dtype: object

obj = pd.Series(np.arange(4), index=["d", "a", "b", "c"])
obj

d    0
a    1
b    2
c    3
dtype: int32

obj.sort_index() # 인덱스 오름차순

a    1
b    2
c    3
d    0
dtype: int32

frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
                     index=["three", "one"],
                     columns=["d", "a", "b", "c"])
frame

	d	a	b	c
three	0	1	2	3
one	4	5	6	7

frame.sort_index()

	d	a	b	c
one	4	5	6	7
three	0	1	2	3

frame.sort_index(axis="columns") # 컬럼 정렬

	a	b	c	d
three	1	2	3	0
one	5	6	7	4

frame.sort_index(axis="columns", ascending=False) # 내림차순

	d	c	b	a
three	0	3	2	1
one	4	7	6	5

obj = pd.Series([4, 7, -3, 2])
obj.sort_values() # 시리즈 값들이 오름차순

2   -3
3    2
0    4
1    7
dtype: int64

obj = pd.Series([4, np.nan, 7, np.nan, -3, 2])
obj.sort_values() # NaN은 맨밑

4   -3.0
5    2.0
0    4.0
2    7.0
1    NaN
3    NaN
dtype: float64

obj.sort_values(na_position="first") # NaN이 첫 번째

1    NaN
3    NaN
4   -3.0
5    2.0
0    4.0
2    7.0
dtype: float64

frame = pd.DataFrame({"b": [4, 7, -3, 2], "a": [0, 1, 0, 1]})
frame
frame.sort_values("b") # b만 정렬

	b	a
2	-3	0
3	2	1
0	4	0
1	7	1

frame.sort_values(["a", "b"])

	b	a
2	-3	0
0	4	0
3	2	1
1	7	1

obj = pd.Series([7, -5, 7, 4, 2, 0, 4])
obj

0    7
1   -5
2    7
3    4
4    2
5    0
6    4
dtype: int64

obj.rank()

0    6.5
1    1.0
2    6.5
3    4.5
4    3.0
5    2.0
6    4.5
dtype: float64

obj.rank(method="first") # 동일 순위있어도 더 큰 순위 표시

0    6.0
1    1.0
2    7.0
3    4.0
4    3.0
5    2.0
6    5.0
dtype: float64

obj.rank(ascending=False) # 순위 내림차순

0    1.5
1    7.0
2    1.5
3    3.5
4    5.0
5    6.0
6    3.5
dtype: float64

frame = pd.DataFrame({"b": [4.3, 7, -3, 2], "a": [0, 1, 0, 1],
                      "c": [-2, 5, 8, -2.5]})
frame

	b	a	c
0	4.3	0	-2.0
1	7.0	1	5.0
2	-3.0	0	8.0
3	2.0	1	-2.5

frame.rank(axis="columns") # 행

	b	a	c
0	3.0	2.0	1.0
1	3.0	1.0	2.0
2	1.0	2.0	3.0
3	3.0	2.0	1.0

obj = pd.Series(np.arange(5), index=["a", "a", "b", "b", "c"])
obj

a    0
a    1
b    2
b    3
c    4
dtype: int32

obj.index.is_unique # 인덱스에 중복값 있으면 False

False

obj["a"], obj["c"]

(a    0
 a    1
 dtype: int32,
 4)

df = pd.DataFrame(np.random.standard_normal((5, 3)),
                  index=["a", "a", "b", "b", "c"])
df

	0	1	2
a	0.274992	0.228913	1.352917
a	0.886429	-2.001637	-0.371843
b	1.669025	-0.438570	-0.539741
b	0.476985	3.248944	-1.021228
c	-0.577087	0.124121	0.302614

df.loc["b"]

	0	1	2
b	1.669025	-0.438570	-0.539741
b	0.476985	3.248944	-1.021228

df.loc["c"]

0   -0.577087
1    0.124121
2    0.302614
Name: c, dtype: float64

df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=["a", "b", "c", "d"],
                  columns=["one", "two"])
df

	one	two
a	1.40	NaN
b	7.10	-4.5
c	NaN	NaN
d	0.75	-1.3

df.sum()

one    9.25
two   -5.80
dtype: float64

df.sum(axis="columns") #행

a    1.40
b    2.60
c    0.00
d   -0.55
dtype: float64

# index : 열
df.sum(axis="index", skipna=False) , df.sum(axis="columns", skipna=False) # 결측값 포함 계산 # 행

(one   NaN
 two   NaN
 dtype: float64,
 a     NaN
 b    2.60
 c     NaN
 d   -0.55
 dtype: float64)

df.mean(axis="columns") # 모두 NaN 이었으면 NaN

a    1.400
b    1.300
c      NaN
d   -0.275
dtype: float64

df.idxmax() # 각 열에 최대값에 해당하는 행 이름 출력

one    b
two    d
dtype: object

df.cumsum() # 각 열 누적합

	one	two
a	1.40	NaN
b	8.50	-4.5
c	NaN	NaN
d	9.25	-5.8

df.describe() # 각 열 통계정보

	one	two
count	3.000000	2.000000
mean	3.083333	-2.900000
std	3.493685	2.262742
min	0.750000	-4.500000
25%	1.075000	-3.700000
50%	1.400000	-2.900000
75%	4.250000	-2.100000
max	7.100000	-1.300000

obj = pd.Series(["a", "a", "b", "c"] * 4) # 4개 값 만들기
obj

0     a
1     a
2     b
3     c
4     a
5     a
6     b
7     c
8     a
9     a
10    b
11    c
12    a
13    a
14    b
15    c
dtype: object

obj.describe() # 통계정보

count     16
unique     3
top        a
freq       8
dtype: object

price = pd.read_pickle("C:/Users/seong taek/3-1 Python_Hard/yahoo_price.pkl")
volume = pd.read_pickle("C:/Users/seong taek/3-1 Python_Hard/yahoo_volume.pkl")
price

	AAPL	GOOG	IBM	MSFT
Date
2010-01-04	27.990226	313.062468	113.304536	25.884104
2010-01-05	28.038618	311.683844	111.935822	25.892466
2010-01-06	27.592626	303.826685	111.208683	25.733566
2010-01-07	27.541619	296.753749	110.823732	25.465944
2010-01-08	27.724725	300.709808	111.935822	25.641571
…	…	…	…	…
2016-10-17	117.550003	779.960022	154.770004	57.220001
2016-10-18	117.470001	795.260010	150.720001	57.660000
2016-10-19	117.120003	801.500000	151.259995	57.529999
2016-10-20	117.059998	796.969971	151.520004	57.250000
2016-10-21	116.599998	799.369995	149.630005	59.660000

1714 rows × 4 columns

volume

	AAPL	GOOG	IBM	MSFT
Date
2010-01-04	123432400	3927000	6155300	38409100
2010-01-05	150476200	6031900	6841400	49749600
2010-01-06	138040000	7987100	5605300	58182400
2010-01-07	119282800	12876600	5840600	50559700
2010-01-08	111902700	9483900	4197200	51197400
…	…	…	…	…
2016-10-17	23624900	1089500	5890400	23830000
2016-10-18	24553500	1995600	12770600	19149500
2016-10-19	20034600	116600	4632900	22878400
2016-10-20	24125800	1734200	4023100	49455600
2016-10-21	22384800	1260500	4401900	79974200

1714 rows × 4 columns

returns = price.pct_change() # 변화율 추출
returns

	AAPL	GOOG	IBM	MSFT
Date
2010-01-04	NaN	NaN	NaN	NaN
2010-01-05	0.001729	-0.004404	-0.012080	0.000323
2010-01-06	-0.015906	-0.025209	-0.006496	-0.006137
2010-01-07	-0.001849	-0.023280	-0.003462	-0.010400
2010-01-08	0.006648	0.013331	0.010035	0.006897
…	…	…	…	…
2016-10-17	-0.000680	0.001837	0.002072	-0.003483
2016-10-18	-0.000681	0.019616	-0.026168	0.007690
2016-10-19	-0.002979	0.007846	0.003583	-0.002255
2016-10-20	-0.000512	-0.005652	0.001719	-0.004867
2016-10-21	-0.003930	0.003011	-0.012474	0.042096

1714 rows × 4 columns

returns["MSFT"].corr(returns["IBM"]), returns["MSFT"].cov(returns["IBM"]) # 상관관계, 공분산

(0.49976361144151155, 8.870655479703546e-05)

returns.corr(), returns.cov()

(          AAPL      GOOG       IBM      MSFT
 AAPL  1.000000  0.407919  0.386817  0.389695
 GOOG  0.407919  1.000000  0.405099  0.465919
 IBM   0.386817  0.405099  1.000000  0.499764
 MSFT  0.389695  0.465919  0.499764  1.000000,
           AAPL      GOOG       IBM      MSFT
 AAPL  0.000277  0.000107  0.000078  0.000095
 GOOG  0.000107  0.000251  0.000078  0.000108
 IBM   0.000078  0.000078  0.000146  0.000089
 MSFT  0.000095  0.000108  0.000089  0.000215)

returns.corrwith(returns["IBM"]) # 각열과의 상관관계

AAPL    0.386817
GOOG    0.405099
IBM     1.000000
MSFT    0.499764
dtype: float64

returns.corrwith(volume)

AAPL   -0.075565
GOOG   -0.007067
IBM    -0.204849
MSFT   -0.092950
dtype: float64

obj = pd.Series(["c", "a", "d", "a", "a", "b", "b", "c", "c"])
obj

0    c
1    a
2    d
3    a
4    a
5    b
6    b
7    c
8    c
dtype: object

uniques = obj.unique()
uniques

array(['c', 'a', 'd', 'b'], dtype=object)

obj.value_counts() # 고유값 개수

c    3
a    3
b    2
d    1
dtype: int64

pd.value_counts(obj.to_numpy(), sort=False) # 넘파이 배열에서 각 값의 개수

c    3
a    3
d    1
b    2
dtype: int64

obj
mask = obj.isin(["b", "c"]) # isin : 찾기
mask
obj[mask]

0    c
5    b
6    b
7    c
8    c
dtype: object

to_match = pd.Series(["c", "a", "b", "b", "c", "a"])
unique_vals = pd.Series(["c", "b", "a"])
indices = pd.Index(unique_vals).get_indexer(to_match)
indices

array([0, 2, 1, 1, 0, 2], dtype=int64)

data = pd.DataFrame({"Qu1": [1, 3, 4, 3, 4],
                     "Qu2": [2, 3, 1, 2, 3],
                     "Qu3": [1, 5, 2, 4, 4]})
data

	Qu1	Qu2	Qu3
0	1	2	1
1	3	3	5
2	4	1	2
3	3	2	4
4	4	3	4

data["Qu1"].value_counts().sort_index() # 인덱스 오름차순

1    1
3    2
4    2
Name: Qu1, dtype: int64

result = data.apply(pd.value_counts).fillna(0) # 인덱스 : 모든 value값 , value : 개수
result

	Qu1	Qu2	Qu3
1	1.0	1.0	1.0
2	0.0	2.0	1.0
3	2.0	2.0	0.0
4	2.0	0.0	2.0
5	0.0	0.0	1.0

data = pd.DataFrame({"a": [1, 1, 1, 2, 2], "b": [0, 0, 1, 0, 0]})
data

	a	b
0	1	0
1	1	0
2	1	1
3	2	0
4	2	0

data.value_counts() # 행단위로 개수 파악

a  b
1  0    2
2  0    2
1  1    1
dtype: int64

pd.options.display.max_rows = PREVIOUS_MAX_ROWS
PREVIOUS_MAX_ROWS

df = pd.read_csv("pandas_practice.csv")
df

	이름	발표횟수
0	강동환	0
1	김대천	0
2	김성태	0
3	김수경	0
4	김승일	0
5	김재현	0
6	김주영	0
7	김주향	0
8	김지환	0
9	김진용	0
10	김희수	0
11	노건우	0
12	박동균	0
13	박성빈	0
14	박성수	0
15	박성진	0
16	박정아	0
17	박준규	0
18	서보연	0
19	손현동	0
20	송치민	0
21	신동훈	0
22	신혜람	0
23	양정현	0
24	유병우	0
25	유지의	0
26	유채영	0
27	윤서림	0
28	윤여린	0
29	윤정수	0
30	이강륜	0
31	이민재	0
32	이주영	0
33	이지호	0
34	이현상	0
35	인지영	0
36	임준열	0
37	임채리	0
38	전병훈	0
39	전효원	0
40	정대규	0
41	정서연	0
42	정진아	0
43	정형욱	0
44	조성택	0
45	조준하	0
46	조중석	0
47	조철민	0
48	조효진	0
49	채준기	0
50	최송연	0
51	최원준	0
52	최재혁	0
53	최희승	0
54	홍예린	0

랜덤 학생 뽑기

def pop_student(df=df):
    length = df.shape[0]
    rand_num = np.random.randint(0,length)
    name = df.iloc[rand_num]["이름"]
    print(f"축하합니다! {name} 학생이 당첨되었습니다")

pop_student(df)

축하합니다! 정서연 학생이 당첨되었습니다

위의 df에서 학생의 성을 “성”이라는 컬럼에 매핑해 봅시다

df["성"] = df.apply(lambda x: x["이름"][0], axis=1)
df

	이름	성
0	강동환	강
1	김대천	김
2	김성태	김
3	김수경	김
4	김승일	김
5	김재현	김
6	김주영	김
7	김주향	김
8	김지환	김
9	김진용	김
10	김희수	김
11	노건우	노
12	박동균	박
13	박성빈	박
14	박성수	박
15	박성진	박
16	박정아	박
17	박준규	박
18	서보연	서
19	손현동	손
20	송치민	송
21	신동훈	신
22	신혜람	신
23	양정현	양
24	유병우	유
25	유지의	유
26	유채영	유
27	윤서림	윤
28	윤여린	윤
29	윤정수	윤
30	이강륜	이
31	이민재	이
32	이주영	이
33	이지호	이
34	이현상	이
35	인지영	인
36	임준열	임
37	임채리	임
38	전병훈	전
39	전효원	전
40	정대규	정
41	정서연	정
42	정진아	정
43	정형욱	정
44	조성택	조
45	조준하	조
46	조중석	조
47	조철민	조
48	조효진	조
49	채준기	채
50	최송연	최
51	최원준	최
52	최재혁	최
53	최희승	최
54	홍예린	홍

df["성"].unique().shape # 20개의 서로 다른 성씨

(20,)

df["성"].value_counts()

김    10
박     6
조     5
이     5
최     4
정     4
윤     3
유     3
임     2
신     2
전     2
채     1
강     1
인     1
양     1
송     1
손     1
서     1
노     1
홍     1
Name: 성, dtype: int64

df.loc[df["성"]=="조"]

	이름	성
44	조성택	조
45	조준하	조
46	조중석	조
47	조철민	조
48	조효진	조

df.loc[df["성"]=="조","이름"] # 조씨인 '이름' 정보만 추출

44    조성택
45    조준하
46    조중석
47    조철민
48    조효진
Name: 이름, dtype: object

df.shape[0] # 행 개수

결석한 학생들은 빼고 학생을 출력되도록 업데이트 해봅시다

absence = ["조성택", "최원준", "정대규", "이강륜", "노건우", "김재현", "윤여린",
          "김희수", "최송연"]

def pop_student_update(df=df, absence=absence):
    df_present = df[~df['이름'].isin(absence)].reset_index(drop=True)
    length = df_present.shape[0]
    rand_num = np.random.randint(0, length)
    name = df_present.iloc[rand_num]["이름"]
    print(f"축하합니다! {name} 학생이 당첨되었습니다")
    
pop_student_update(df)

축하합니다! 신동훈 학생이 당첨되었습니다

df.loc[~df["이름"].isin(absence)] # absence 제외 이름 추출

	이름	성
0	강동환	강
1	김대천	김
2	김성태	김
3	김수경	김
4	김승일	김
6	김주영	김
7	김주향	김
8	김지환	김
9	김진용	김
12	박동균	박
13	박성빈	박
14	박성수	박
15	박성진	박
16	박정아	박
17	박준규	박
18	서보연	서
19	손현동	손
20	송치민	송
21	신동훈	신
22	신혜람	신
23	양정현	양
24	유병우	유
25	유지의	유
26	유채영	유
27	윤서림	윤
29	윤정수	윤
31	이민재	이
32	이주영	이
33	이지호	이
34	이현상	이
35	인지영	인
36	임준열	임
37	임채리	임
38	전병훈	전
39	전효원	전
41	정서연	정
42	정진아	정
43	정형욱	정
45	조준하	조
46	조중석	조
47	조철민	조
48	조효진	조
49	채준기	채
52	최재혁	최
53	최희승	최
54	홍예린	홍

뽑힌 학생들에 대해, 발표횟수를 업데이트 할 수 있도록 코드를 고쳐봅시다

df.loc[df['이름']=='조성택']

	이름	발표횟수	성
44	조성택	0	조

df.loc[df['이름']=='조성택']['발표횟수'] # 발표횟수 추출

44    0
Name: 발표횟수, dtype: int64

df.loc[df['이름']=='조성택','발표횟수'] +=1 # 발표횟수 1 늘리기
df

	이름	발표횟수	성
0	강동환	0	강
1	김대천	0	김
2	김성태	0	김
3	김수경	0	김
4	김승일	0	김
5	김재현	0	김
6	김주영	0	김
7	김주향	0	김
8	김지환	0	김
9	김진용	0	김
10	김희수	0	김
11	노건우	0	노
12	박동균	0	박
13	박성빈	0	박
14	박성수	0	박
15	박성진	0	박
16	박정아	0	박
17	박준규	0	박
18	서보연	0	서
19	손현동	0	손
20	송치민	0	송
21	신동훈	0	신
22	신혜람	0	신
23	양정현	0	양
24	유병우	0	유
25	유지의	0	유
26	유채영	0	유
27	윤서림	0	윤
28	윤여린	0	윤
29	윤정수	0	윤
30	이강륜	0	이
31	이민재	0	이
32	이주영	0	이
33	이지호	0	이
34	이현상	0	이
35	인지영	0	인
36	임준열	0	임
37	임채리	0	임
38	전병훈	0	전
39	전효원	0	전
40	정대규	0	정
41	정서연	0	정
42	정진아	0	정
43	정형욱	0	정
44	조성택	1	조
45	조준하	0	조
46	조중석	0	조
47	조철민	0	조
48	조효진	0	조
49	채준기	0	채
50	최송연	0	최
51	최원준	0	최
52	최재혁	0	최
53	최희승	0	최
54	홍예린	0	홍

df.iloc[np.random.randint(0,55)] # 0~55행 중 랜덤으로 행 추출

이름      최송연
발표횟수      0
성         최
Name: 50, dtype: object

frame = pd.DataFrame(np.random.standard_normal((4,3)),
                    columns=list("bde"),
                    index=["Utah", "Ohio", "Texas", "Oregon"])
frame

	b	d	e
Utah	0.523772	-0.144327	1.910040
Ohio	1.808867	-1.105941	0.344533
Texas	1.553014	0.547801	0.256437
Oregon	-1.512917	-0.878108	-0.017276

series2 = pd.Series(np.arange(3), index=["b", "e", "f"])
series2

b    0
e    1
f    2
dtype: int32

frame + series2 # d는 frame에 밖에 없어서 NaN, f는 series 밖에 없어서 NaN

	b	d	e	f
Utah	0.523772	NaN	2.910040	NaN
Ohio	1.808867	NaN	1.344533	NaN
Texas	1.553014	NaN	1.256437	NaN
Oregon	-1.512917	NaN	0.982724	NaN

series3 = frame["d"] # d열 정보 추출
series3

Utah     -0.144327
Ohio     -1.105941
Texas     0.547801
Oregon   -0.878108
Name: d, dtype: float64

frame.loc[:,"d"] # d열 정보 추출

Utah     -0.144327
Ohio     -1.105941
Texas     0.547801
Oregon   -0.878108
Name: d, dtype: float64

frame.sub(series3, axis="index") # 인덱스 기준으로 d값 제거

	b	e
Utah	0.668099	2.054368
Ohio	2.914808	1.450473
Texas	1.005214	-0.291364
Oregon	-0.634809	0.860832

frame - series3 # series값이 부여된 열 없이 값만 있기 때문에 NaN

	Ohio	Oregon	Texas	Utah	b	d	e
Utah	NaN	NaN	NaN	NaN	NaN	NaN	NaN
Ohio	NaN	NaN	NaN	NaN	NaN	NaN	NaN
Texas	NaN	NaN	NaN	NaN	NaN	NaN	NaN
Oregon	NaN	NaN	NaN	NaN	NaN	NaN	NaN

col_d = frame["d"]
df_d = pd.DataFrame(col_d)
df_d

	d
Utah	-0.144327
Ohio	-1.105941
Texas	0.547801
Oregon	-0.878108

frame - df_d # d열만 제거 되고 나머지 NaN

	b	e
Utah	NaN	NaN
Ohio	NaN	NaN
Texas	NaN	NaN
Oregon	NaN	NaN

frame.sub(df_d)

	b	e
Utah	NaN	NaN
Ohio	NaN	NaN
Texas	NaN	NaN
Oregon	NaN	NaN

frame

	b	d	e
Utah	0.523772	-0.144327	1.910040
Ohio	1.808867	-1.105941	0.344533
Texas	1.553014	0.547801	0.256437
Oregon	-1.512917	-0.878108	-0.017276

def f1(x):
    return x.max() - x.min() # 최대 - 최소 함수 생성, 열 기준

frame.apply(f1)  # axis = 0

b    3.321785
d    1.653742
e    1.927316
dtype: float64

np.abs(frame)

	b	d	e
Utah	0.523772	0.144327	1.910040
Ohio	1.808867	1.105941	0.344533
Texas	1.553014	0.547801	0.256437
Oregon	1.512917	0.878108	0.017276

x = frame["b"]
x

Utah      0.523772
Ohio      1.808867
Texas     1.553014
Oregon   -1.512917
Name: b, dtype: float64

f1(x)

3.3217845711306135

함수보다 더 간단한 lambda

frame.apply(lambda x: x.max()-x.min(), axis=0)

b    3.321785
d    1.653742
e    1.927316
dtype: float64

frame.apply(f1, axis="columns") # 행 기준

Utah      2.054368
Ohio      2.914808
Texas     1.296577
Oregon    1.495641
dtype: float64

def f2(x):
    return pd.Series([x.min(),x.max()], index=["min", "max"])

frame.apply(f2)

	b	d	e
min	-1.512917	-1.105941	-0.017276
max	1.808867	0.547801	1.910040

frame[["min", "max"]] = frame.apply(f2, axis=1) # 새로운 인덱스로 만들기
frame

	b	d	e	min	max
Utah	0.523772	-0.144327	1.910040	-0.144327	1.910040
Ohio	1.808867	-1.105941	0.344533	-1.105941	1.808867
Texas	1.553014	0.547801	0.256437	0.256437	1.553014
Oregon	-1.512917	-0.878108	-0.017276	-1.512917	-0.017276

# 엘리멘트와이즈

def my_format(x):
    return f"{x:.2f}"

frame.applymap(my_format) # 소수점 둘째까지 반올림

	b	d	e	min	max
Utah	0.52	-0.14	1.91	-0.14	1.91
Ohio	1.81	-1.11	0.34	-1.11	1.81
Texas	1.55	0.55	0.26	0.26	1.55
Oregon	-1.51	-0.88	-0.02	-1.51	-0.02

frame["e"]

Utah      1.910040
Ohio      0.344533
Texas     0.256437
Oregon   -0.017276
Name: e, dtype: float64

## sort

obj = pd.Series(np.arange(4), index=["d","a","b","c"])
obj

d    0
a    1
b    2
c    3
dtype: int32

obj.sort_index()

a    1
b    2
c    3
d    0
dtype: int32

frame = pd.DataFrame(np.arange(8).reshape((2,4)),
                    index=["three", "one"],
                    columns=["d", "a", "b","c"])
frame

	d	a	b	c
three	0	1	2	3
one	4	5	6	7

frame.sort_index()

	d	a	b	c
one	4	5	6	7
three	0	1	2	3

frame = pd.DataFrame({"b": [4.3, 7, -3, 2], "a": [0,1,0,1],
                     "c": [-2,5,8,-2.5]})

frame

	b	a	c
0	4.3	0	-2.0
1	7.0	1	5.0
2	-3.0	0	8.0
3	2.0	1	-2.5

frame.shape

(4, 3)

frame.rank(axis="columns") # 행기준 순위

	b	a	c
0	3.0	2.0	1.0
1	3.0	1.0	2.0
2	1.0	2.0	3.0
3	3.0	2.0	1.0

frame.rank(axis="index") # 열기준, 중복값은 순위의 평균으로 매김

	b	a	c
0	3.0	1.5	2.0
1	4.0	3.5	3.0
2	1.0	1.5	4.0
3	2.0	3.5	1.0

absence = ['조성택']

df["이름"].isin(absence)

0     False
1     False
2     False
3     False
4     False
5     False
6     False
7     False
8     False
9     False
10    False
11    False
12    False
13    False
14    False
15    False
16    False
17    False
18    False
19    False
20    False
21    False
22    False
23    False
24    False
25    False
26    False
27    False
28    False
29    False
30    False
31    False
32    False
33    False
34    False
35    False
36    False
37    False
38    False
39    False
40    False
41    False
42    False
43    False
44     True
45    False
46    False
47    False
48    False
49    False
50    False
51    False
52    False
53    False
54    False
Name: 이름, dtype: bool